let MS = require('./ms.js')
const request = require('./request.js')
const {
    isString,
    isNumber,
    isUndefined,
    isArray,
    isBoolean,
    isObject
} = require('./dataType')

const note = class note {
    constructor() {

    }

    getNote(id) {
        let params = {
            noteId: id
        }
        return new Promise((resolve, reject) => {
            request(MS._config.parameters.NOTE.GET_NOTE.url,
                MS._config.parameters.NOTE.GET_NOTE.method, params).then(res => {
                resolve(res.data)
            }).catch(err => {
                reject(err)
            })
        })
    }

    findNote(options) {
        let params = {
            pageSize: 10,
            pageNum: 1
        }
        if(!isUndefined(options) && isObject(options)) {
            if(!isUndefined(options.userId) && isString(options.userId)) {
                params.userId = options.userId;
            }
            if(!isUndefined(options.topicId) && isString(options.topicId)) {
                params.topicId = options.topicId;
            }
            if(!isUndefined(options.isPublic) && isBoolean(options.isPublic)) {
                params.isPublic = options.isPublic;
            }
            if(!isUndefined(options.isRecommend) && isBoolean(options.isRecommend)) {
                params.isRecommend = options.isRecommend;
            }
            if(!isUndefined(options.isVideo) && isBoolean(options.isVideo)) {
                params.isVideo = options.isVideo;
            }
            if(!isUndefined(options.examineStatus) && isNumber(options.examineStatus)) {
                params.examineStatus = options.examineStatus
            }
            if(!isUndefined(options.labelIds) && isArray(options.labelIds)) {
                params.labelIds = options.labelIds.join(',')
            }
            if(!isUndefined(options.pageSize) && isNumber(options.pageSize)) {
                params.pageSize = options.pageSize;
            }
            if(!isUndefined(options.pageNum) && isNumber(options.pageNum)) {
                params.pageNum = options.pageNum;
            }
        }
        return new Promise((resolve, reject) => {
            request(MS._config.parameters.NOTE.FIND_NOTE.url,
                MS._config.parameters.NOTE.FIND_NOTE.method, params).then(res => {
                resolve(res.data)
            }).catch(err => {
                reject(err)
            })
        })
    }

    remove(id) {
        let params = {
            id: id
        }
        return new Promise((resolve, reject) => {
            request(MS._config.parameters.NOTE.REMOVE.url,
                MS._config.parameters.NOTE.REMOVE.method, params).then(res => {
                resolve(res.data)
            }).catch(err => {
                reject(err)
            })
        })
    }

    save(options) {
        let params = {}
        if(!isUndefined(options.id) && isString(options.id)) {
            params.id = options.id;
        }
        if(!isUndefined(options.context) && isString(options.context)) {
            params.context = options.context;
        }
        if(!isUndefined(options.userId) && isString(options.userId)) {
            params.userId = options.userId;
        }
        if(!isUndefined(options.isPublic) && isBoolean(options.isPublic)) {
            params.isPublic = options.isPublic;
        }
        if(!isUndefined(options.topicId) && isString(options.topicId)) {
            params.topicId = options.topicId;
        }
        if(!isUndefined(options.topicName) && isString(options.topicName)) {
            params.topicName = options.topicName;
        }
        if(!isUndefined(options.isVideo) && isBoolean(options.isVideo)) {
            params.isVideo = options.isVideo;
        }
        if(!isUndefined(options.labelIds) && isArray(options.labelIds)) {
            params.labelIds = options.labelIds.join(',');
        }
        if(!isUndefined(options.files) && isArray(options.files)) {
            params.files = options.files.join(',');
        }
        return new Promise((resolve, reject) => {
            request(MS._config.parameters.NOTE.SAVE.url,
                MS._config.parameters.NOTE.SAVE.method, params).then(res => {
                resolve(res.data)
            }).catch(err => {
                reject(err)
            })
        })
    }

    favorite(options) {
        if(!MS.User.current()) {
            throw new Error(416, "当前用户未登录")
        }
        let params = {
            userId: MS.User.current().id
        }
        if(!isUndefined(options.userId) && isString(options.userId)) {
            params.userId = options.userId;
        }
        if(!isUndefined(options.noteId) && isString(options.noteId)) {
            params.noteId = options.noteId;
        }
        return new Promise((resolve, reject) => {
            request(MS._config.parameters.NOTE.FAVORITE.url,
                MS._config.parameters.NOTE.FAVORITE.method, params).then(res => {
                resolve(res.data)
            }).catch(err => {
                reject(err)
            })
        })
    }

    cancelFavorite(options) {
        if(!MS.User.current()) {
            throw new Error(416, "当前用户未登录")
        }
        let params = {
            userId: MS.User.current().id
        }
        if(!isUndefined(options.noteId) && isString(options.noteId)) {
            params.noteId = options.noteId;
        }
        return new Promise((resolve, reject) => {
            request(MS._config.parameters.NOTE.CANCEL_FAVORITE.url,
                MS._config.parameters.NOTE.CANCEL_FAVORITE.method, params).then(res => {
                resolve(res.data)
            }).catch(err => {
                reject(err)
            })
        })
    }

    checkFavorite(options) {
        if(!MS.User.current()) {
            throw new Error(416, "当前用户未登录")
        }
        let params = {
            userId: MS.User.current().id
        }
        if(!isUndefined(options.noteId) && isString(options.noteId)) {
            params.noteId = options.noteId;
        }
        return new Promise((resolve, reject) => {
            request(MS._config.parameters.NOTE.CHECK_FAVORITE.url,
                MS._config.parameters.NOTE.CHECK_FAVORITE.method, data).then(res => {
                resolve(res.data)
            }).catch(err => {
                reject(err)
            })
        })
    }

    praise(options) {
        if(!MS.User.current()) {
            throw new Error(416, "当前用户未登录")
        }
        let params = {
            userId: MS.User.current().id
        }
        if(!isUndefined(options.noteId) && isString(options.noteId)) {
            params.noteId = options.noteId;
        }
        return new Promise((resolve, reject) => {
            request(MS._config.parameters.NOTE.PRAISE.url,
                MS._config.parameters.NOTE.PRAISE.method, params).then(res => {
                resolve(res.data)
            }).catch(err => {
                reject(err)
            })
        })
    }

    cancelPraise(options) {
        if(!MS.User.current()) {
            throw new Error(416, "当前用户未登录")
        }
        let params = {
            userId: MS.User.current().id
        }
        if(!isUndefined(options.noteId) && isString(options.noteId)) {
            params.noteId = options.noteId;
        }
        return new Promise((resolve, reject) => {
            request(MS._config.parameters.NOTE.CANCEL_PRAISE.url,
                MS._config.parameters.NOTE.CANCEL_PRAISE.method, params).then(res => {
                resolve(res.data)
            }).catch(err => {
                reject(err)
            })
        })
    }

    enable(id) {
        let params = {
            noteId: id
        }
        return new Promise((resolve, reject) => {
            request(MS._config.parameters.NOTE.ENABLE.url,
                MS._config.parameters.NOTE.ENABLE.method, params).then(res => {
                resolve(res.data)
            }).catch(err => {
                reject(err)
            })
        })
    }

    disable(id) {
        let params = {
            noteId: id
        }
        return new Promise((resolve, reject) => {
            request(MS._config.parameters.NOTE.DISABLE.url,
                MS._config.parameters.NOTE.DISABLE.method, params).then(res => {
                resolve(res.data)
            }).catch(err => {
                reject(err)
            })
        })
    }
}

module.exports = note